Prawn::Errors::IncompatibleStringEncoding in ConsolidacoesController#gerar_pdf_holerite

144
145
146
147
148
149
              

             ::Encoding::UndefinedConversionError

        raise Prawn::Errors::IncompatibleStringEncoding,
          "Your document includes text that's not compatible with the " \
            "Windows-1252 character set.\n" \
            'If you need full UTF-8 support, use external fonts instead of ' \

139
140
141
142
143
144
              

      # @param text [String]
      # @return [String]
      def normalize_encoding(text)
        text.encode('windows-1252')
      rescue ::Encoding::InvalidByteSequenceError,
             ::Encoding::UndefinedConversionError

448
449
450
451
452
453
              

              end
            else
              hash[:text] = @document.font.normalize_encoding(hash[:text])
            end
          end

442
443
444
445
446
447
              

          end

          formatted_text.each do |hash|
            if hash[:font]
              @document.font(hash[:font]) do
                hash[:text] = @document.font.normalize_encoding(hash[:text])

442
443
444
445
446
447
              

          end

          formatted_text.each do |hash|
            if hash[:font]
              @document.font(hash[:font]) do
                hash[:text] = @document.font.normalize_encoding(hash[:text])

420
421
422
423
424
425
              

        def normalized_text(flags)
          text = normalize_encoding

          text.each { |t| t.delete(:color) } if flags[:dry_run]

257
258
259
260
261
262
              

                process_options

                text = normalized_text(flags)

                @document.font_size(@font_size) do
                  shrink_to_fit(text) if @overflow == :shrink_to_fit

229
230
231
232
233
234
              

        if text_rendering_mode == mode
          yield
        else
          wrap_and_restore_text_rendering_mode(mode, &block)
        end

254
255
256
257
258
259
              

          @document.save_font do
            @document.character_spacing(@character_spacing) do
              @document.text_rendering_mode(@mode) do
                process_options

                text = normalized_text(flags)

258
259
260
261
262
263
              

        if character_spacing == amount
          yield
        else
          wrap_and_restore_character_spacing(amount, &block)
        end

253
254
255
256
257
258
              

          @document.save_font do
            @document.character_spacing(@character_spacing) do
              @document.text_rendering_mode(@mode) do
                process_options

258
259
260
261
262
263
              

      original_size = @font_size

      yield
    ensure
      set_font(original_font, original_size) if original_font
    end

252
253
254
255
256
257
              

          unprinted_text = []

          @document.save_font do
            @document.character_spacing(@character_spacing) do
              @document.text_rendering_mode(@mode) do
                process_options

185
186
187
188
189
190
              

      #   If not wide enough to print any text.
      def render(flags = {})
        leftover = super(flags)
        leftover.map { |hash| hash[:text] }.join
      end
    end

95
96
97
98
99
100
              

        end

      box.render
    end

    # @group Experimental API

41
42
43
44
45
46
              

      end

      desenhar_selo_pagamento

      secao "PROVENTOS E DESCONTOS"

18
19
20
21
22
23
              

    def render
      cabecalho
      corpo
      rodape
      @pdf.render
    end

228
229
230
231
232
233
              

    auditar!(:editar, @consolidacao, dados_novos: { pdf: 'holerite', motorista: motorista })

    send_data pdf.render,
              filename:    "holerite_#{motorista.parameterize}_#{@consolidacao.id}.pdf",
              type:        'application/pdf',
              disposition: 'attachment'

4
5
6
7
8
9
              

  module BasicImplicitRender # :nodoc:
    def send_action(method, *args)
      ret = super
      default_render unless performed?
      ret
    end

222
223
224
225
226
227
              

      # which is *not* necessarily the same as the action name.
      def process_action(...)
        send_action(...)
      end

      # Actually call the method associated with the action. Override

163
164
165
166
167
168
              

      def process_action(*) # :nodoc:
        self.formats = request.formats.filter_map(&:ref)
        super
      end

      def _process_variant(options)

257
258
259
260
261
262
              

      def process_action(...)
        run_callbacks(:process_action) do
          super
        end
      end
  end

119
120
121
122
123
124
              

              current.invoke_before(env)
              if current.final?
                env.value = !env.halted && (!block_given? || yield)
              elsif current.skip?(env)
                (skipped ||= []) << current
                next_sequence = next_sequence.nested

22
23
24
25
26
27
              

    def with_request_id(request_id)
      old_request_id, self.current_request_id = self.current_request_id, request_id
      yield
    ensure
      self.current_request_id = old_request_id
    end

8
9
10
11
12
              

  private
    def turbo_tracking_request_id(&block)
      Turbo.with_request_id(request.headers["X-Turbo-Request-Id"], &block)
    end
end

128
129
130
131
132
133
              

                begin
                  target, block, method, *arguments = current.expand_call_template(env, invoke_sequence)
                  target.send(method, *arguments, &block)
                ensure
                  next_sequence = current
                end

21
22
23
24
25
26
              

        previous_renderer = self.renderer
        self.renderer = renderer
        yield
      ensure
        self.renderer = previous_renderer
      end

67
68
69
70
71
72
              

        ActiveSupport.on_load(base) do
          around_action do |controller, action|
            ActionText::Content.with_renderer(controller, &action)
          end
        end
      end

128
129
130
131
132
133
              

                begin
                  target, block, method, *arguments = current.expand_call_template(env, invoke_sequence)
                  target.send(method, *arguments, &block)
                ensure
                  next_sequence = current
                end

128
129
130
131
132
133
              

                begin
                  target, block, method, *arguments = current.expand_call_template(env, invoke_sequence)
                  target.send(method, *arguments, &block)
                ensure
                  next_sequence = current
                end

139
140
141
142
143
144
              

          end

          invoke_sequence.call
        end
      end
    end

256
257
258
259
260
261
              

      # <tt>process_action</tt> callbacks around the normal behavior.
      def process_action(...)
        run_callbacks(:process_action) do
          super
        end
      end

23
24
25
26
27
28
              

    private
      def process_action(*)
        super
      rescue Exception => exception
        request.env["action_dispatch.show_detailed_exceptions"] ||= show_detailed_exceptions?
        rescue_with_handler(exception) || raise

72
73
74
75
76
77
              

        ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
          result = super
          payload[:response] = response
          payload[:status]   = response.status
          result

204
205
206
207
208
209
              

      def instrument(name, payload = {})
        if notifier.listening?(name)
          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end

56
57
58
59
60
61
              

        handle.start
        begin
          yield payload if block_given?
        rescue Exception => e
          payload[:exception] = [e.class.name, e.message]
          payload[:exception_object] = e

204
205
206
207
208
209
              

      def instrument(name, payload = {})
        if notifier.listening?(name)
          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end

71
72
73
74
75
76
              

        ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload)

        ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
          result = super
          payload[:response] = response
          payload[:status]   = response.status

259
260
261
262
263
264
              

      def process_action(*)
        _perform_parameter_wrapping if _wrapper_enabled?
        super
      end

      # Returns the wrapper key which will be used to store wrapped parameters.

30
31
32
33
34
35
              

          # and it won't be cleaned up by the method below.
          ActiveRecord::RuntimeRegistry.reset
          super
        end

        def cleanup_view_runtime

158
159
160
161
162
163
              

      @_response_body = nil

      process_action(action_name, *args)
    end
    ruby2_keywords(:process)

38
39
40
41
42
43
              

    def process(...) # :nodoc:
      old_config, I18n.config = I18n.config, I18nProxy.new(I18n.config, lookup_context)
      super
    ensure
      I18n.config = old_config
    end

225
226
227
228
229
230
              

      set_request!(request)
      set_response!(response)
      process(name)
      request.commit_flash
      to_a
    end

307
308
309
310
311
312
              

        middleware_stack.build(name) { |env| new.dispatch(name, req, res) }.call req.env
      else
        new.dispatch(name, req, res)
      end
    end
  end

47
48
49
50
51
52
              

          def dispatch(controller, action, req, res)
            controller.dispatch(action, req, res)
          end
      end

30
31
32
33
34
35
              

          controller = controller req
          res        = controller.make_response! req
          dispatch(controller, params[:action], req, res)
        rescue ActionController::RoutingError
          if @raise_on_name_error
            raise

49
50
51
52
53
54
              

          req.route_uri_pattern = route.path.spec.to_s

          _, headers, _ = response = route.app.serve(req)

          if "pass" == headers[Constants::X_CASCADE]
            req.script_name     = script_name

129
130
131
132
133
134
              

              path_parameters[name.to_sym] = Utils.unescape_uri(val) if val
            }
            yield [match_data, path_parameters, r]
          }
        end

122
123
124
125
126
127
              

          routes.sort_by!(&:precedence)

          routes.each { |r|
            match_data = r.path.match(path_info)
            path_parameters = {}
            match_data.names.each_with_index { |name, i|

122
123
124
125
126
127
              

          routes.sort_by!(&:precedence)

          routes.each { |r|
            match_data = r.path.match(path_info)
            path_parameters = {}
            match_data.names.each_with_index { |name, i|

30
31
32
33
34
35
              

      def serve(req)
        find_routes(req) do |match, parameters, route|
          set_params  = req.path_parameters
          path_info   = req.path_info
          script_name = req.script_name

880
881
882
883
884
885
              

        req = make_request(env)
        req.path_info = Journey::Router::Utils.normalize_path(req.path_info)
        @router.serve(req)
      end

      def recognize_path(path, environment = {})

34
35
36
37
38
39
              

      result = catch(:warden) do
        env['warden'].on_request
        @app.call(env)
      end

      result ||= {}

32
33
34
35
36
37
              

      env['warden'] = Proxy.new(env, self)
      result = catch(:warden) do
        env['warden'].on_request
        @app.call(env)
      end

32
33
34
35
36
37
              

      env['warden'] = Proxy.new(env, self)
      result = catch(:warden) do
        env['warden'].on_request
        @app.call(env)
      end

18
19
20
21
22
23
              

      begin
        _, _, body = response = @app.call(env)
      rescue Exception
        env[RACK_TEMPFILES]&.each(&:close!)
        raise

27
28
29
30
31
32
              

    def call(env)
      status, headers, body = response = @app.call(env)

      if etag_status?(status) && body.respond_to?(:to_ary) && !skip_caching?(headers)
        body = body.to_ary

29
30
31
32
33
34
              

      case env[REQUEST_METHOD]
      when "GET", "HEAD"
        status, headers, body = response = @app.call(env)

        if status == 200 && fresh?(env, headers)
          response[0] = 304

13
14
15
16
17
18
              

    def call(env)
      _, _, body = response = @app.call(env)

      if env[REQUEST_METHOD] == HEAD
        body.close if body.respond_to?(:close)

34
35
36
37
38
39
              

      def call(env)
        _, headers, _ = response = @app.call(env)

        return response if policy_present?(headers)

34
35
36
37
38
39
              

      def call(env)
        status, headers, _ = response = @app.call(env)

        # Returning CSP headers with a 304 Not Modified is harmful, since nonces in the new
        # CSP headers might not match nonces in the cached HTML.

272
273
274
275
276
277
              

          req = make_request env
          prepare_session(req)
          status, headers, body = app.call(req.env)
          res = Rack::Response::Raw.new status, headers
          commit_session(req, res)
          [status, headers, body]

266
267
268
269
270
271
              

        def call(env)
          context(env)
        end

        def context(env, app = @app)

687
688
689
690
691
692
              

    def call(env)
      request = ActionDispatch::Request.new(env)
      response = @app.call(env)

      if request.have_cookie_jar?
        cookie_jar = request.cookie_jar

653
654
655
656
657
658
              

        end

        @app.call(env)
      end

      private

27
28
29
30
31
32
              

      error = nil
      result = run_callbacks :call do
        @app.call(env)
      rescue => error
      end
      raise error if error

99
100
101
102
103
104
              

      if callbacks.empty?
        yield if block_given?
      else
        env = Filters::Environment.new(self, false, nil)

26
27
28
29
30
31
              

    def call(env)
      error = nil
      result = run_callbacks :call do
        @app.call(env)
      rescue => error
      end

12
13
14
15
16
17
              

      state = @executor.run!(reset: true)
      begin
        response = @app.call(env)

        if env["action_dispatch.report_exception"]
          error = env["action_dispatch.exception"]

14
15
16
17
18
19
              

    def call(env)
      request = ActionDispatch::Request.new(env)
      return @app.call(env) unless actionable_request?(request)

      ActiveSupport::ActionableError.dispatch(request.params[:error].to_s.safe_constantize, request.params[:action])

27
28
29
30
31
32
              

    def call(env)
      _, headers, body = response = @app.call(env)

      if headers[Constants::X_CASCADE] == "pass"
        body.close if body.respond_to?(:close)

130
131
132
133
134
135
              

      def call_app(env)
        @app.call(env)
      rescue => e
        throw :app_exception, e
      end

17
18
19
20
21
22
              

      app_exception = catch :app_exception do
        request = create_regular_or_whiny_request(env)
        return call_app(env) unless request.permitted?

        if id = id_for_repl_session_update(request)
          return update_repl_session(id, request)

15
16
17
18
19
20
              

    def call(env)
      app_exception = catch :app_exception do
        request = create_regular_or_whiny_request(env)
        return call_app(env) unless request.permitted?

15
16
17
18
19
20
              

    def call(env)
      app_exception = catch :app_exception do
        request = create_regular_or_whiny_request(env)
        return call_app(env) unless request.permitted?

29
30
31
32
33
34
              

    def call(env)
      @app.call(env)
    rescue Exception => exception
      request = ActionDispatch::Request.new env
      backtrace_cleaner = request.get_header("action_dispatch.backtrace_cleaner")

35
36
37
38
39
40
              

          logger.info { started_request_message(request) }
          status, headers, body = response = @app.call(env)
          body = ::Rack::BodyProxy.new(body, &handle.method(:finish))

          if response.frozen?

22
23
24
25
26
27
              

        if logger.respond_to?(:tagged)
          logger.tagged(*compute_tags(request)) { call_app(request, env) }
        else
          call_app(request, env)
        end

137
138
139
140
141
142
              

    def tagged(*tags)
      if block_given?
        formatter.tagged(*tags) { yield self }
      else
        logger = ActiveSupport::TaggedLogging.new(self)
        logger.formatter.extend LocalTagStorage

37
38
39
40
41
42
              

      def tagged(*tags)
        pushed_count = tag_stack.push_tags(tags).size
        yield self
      ensure
        pop_tags(pushed_count)
      end

137
138
139
140
141
142
              

    def tagged(*tags)
      if block_given?
        formatter.tagged(*tags) { yield self }
      else
        logger = ActiveSupport::TaggedLogging.new(self)
        logger.formatter.extend LocalTagStorage

239
240
241
242
243
244
              

          super(name, *args, **kwargs, &block)
        elsif loggers.one?
          loggers.first.send(name, *args, **kwargs, &block)
        else
          loggers.map { |logger| logger.send(name, *args, **kwargs, &block) }
        end

22
23
24
25
26
27
              

        if logger.respond_to?(:tagged)
          logger.tagged(*compute_tags(request)) { call_app(request, env) }
        else
          call_app(request, env)
        end

9
10
11
12
13
14
              

      ::Rails.logger.silence { @app.call(env) }
    else
      @app.call(env)
    end
  end
end

90
91
92
93
94
95
              

      req = ActionDispatch::Request.new env
      req.remote_ip = GetIp.new(req, check_ip, proxies)
      @app.call(req.env)
    end

    # The GetIp class exists as a way to defer processing of the request data

26
27
28
29
30
31
              

      req = ActionDispatch::Request.new env
      req.request_id = make_request_id(req.headers[@header])
      @app.call(env).tap { |_status, headers, _body| headers[@header] = req.request_id }
    end

    private

26
27
28
29
30
31
              

      end

      @app.call(env)
    end

    def method_override(env)

22
23
24
25
26
27
              

    def call(env)
      start_time = Utils.clock_time
      _, headers, _ = response = @app.call(env)

      request_time = Utils.clock_time - start_time

57
58
59
60
61
62
              

      response = nil
      events = @subscriber.collect_events do
        response = @app.call(env)
      end

      headers = response[1]

22
23
24
25
26
27
              

        events = []
        ActiveSupport::IsolatedExecutionState[KEY] = events
        yield
        events
      ensure
        ActiveSupport::IsolatedExecutionState.delete(KEY)

56
57
58
59
60
61
              

    def call(env)
      response = nil
      events = @subscriber.collect_events do
        response = @app.call(env)
      end

12
13
14
15
16
17
              

      state = @executor.run!(reset: true)
      begin
        response = @app.call(env)

        if env["action_dispatch.report_exception"]
          error = env["action_dispatch.exception"]

35
36
37
38
39
40
              

      end
    else
      @app.call(env)
    end
  end

23
24
25
26
27
28
              

    def call(env)
      @file_handler.attempt(env) || @app.call(env)
    end
  end

129
130
131
132
133
134
              

    def call(env)
      _, headers, body = response = @app.call(env)

      if body.respond_to?(:to_path)
        case type = variation(env)

222
223
224
225
226
227
              

      if skip_it || !config.enabled
        status, headers, body = @app.call(env)
        client_settings.disable_profiling = true
        return client_settings.handle_cookie([status, headers, body])
      end

534
535
536
537
538
539
              

    def call(env)
      req = build_request env
      app.call req.env
    end

    # Defines additional Rack env configuration that is added on each call.

277
278
279
280
281
282
              

      def call(env)
        env[Const::PUMA_CONFIG] = @config
        @app.call(env)
      end
    end

97
98
99
100
101
102
              

        if @supported_http_methods == :any || @supported_http_methods.key?(env[REQUEST_METHOD])
          status, headers, app_body = @thread_pool.with_force_shutdown do
            @app.call(env)
          end
        else
          @log_writer.log "Unsupported HTTP method used: #{env[REQUEST_METHOD]}"

388
389
390
391
392
393
              

        t[:with_force_shutdown] = true
      end
      yield
    ensure
      t[:with_force_shutdown] = false
    end

96
97
98
99
100
101
              

      begin
        if @supported_http_methods == :any || @supported_http_methods.key?(env[REQUEST_METHOD])
          status, headers, app_body = @thread_pool.with_force_shutdown do
            @app.call(env)
          end
        else

470
471
472
473
474
475
              

        while true
          @requests_count += 1
          case handle_request(client, requests + 1)
          when false
            break
          when :async

252
253
254
255
256
257
              

      @status = :run

      @thread_pool = ThreadPool.new(thread_name, options) { |client| process_client client }

      if @queue_requests
        @reactor = Reactor.new(@io_selector_backend) { |c| reactor_wakeup c }

165
166
167
168
169
170
              

          begin
            @out_of_band_pending = true if block.call(work)
          rescue Exception => e
            STDERR.puts "Error reached top of thread-pool: #{e.message} (#{e.class})"
          end